package view_server

import (
	"bigdevops/src/cache"
	"bigdevops/src/common"
	"bigdevops/src/config"
	"bigdevops/src/models"
	"fmt"
	"github.com/gin-gonic/gin"
	"github.com/go-playground/validator/v10"
	"go.uber.org/zap"
	"gopkg.in/yaml.v3"
	batchv1 "k8s.io/api/batch/v1"
	"k8s.io/apimachinery/pkg/api/errors"
	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
	"k8s.io/apimachinery/pkg/fields"
	"k8s.io/client-go/kubernetes"
	"os"
	"sort"
	"strconv"
	"strings"
)

func getK8sCronjobList(c *gin.Context) {

	sc := c.MustGet(common.GIN_CTX_CONFIG_CONFIG).(*config.ServerConfig)

	currentPage, _ := strconv.Atoi(c.DefaultQuery("page", "1"))
	pageSize, _ := strconv.Atoi(c.DefaultQuery("pageSize", "100"))

	offset := 0
	limit := 0
	limit = pageSize
	if currentPage > 1 {
		offset = (currentPage - 1) * limit
	}
	// 这里只能新增 不能去掉，因为是 多种资源共用的query
	searchUserID := c.DefaultQuery("UserID", "")

	searchUserIDInt, _ := strconv.Atoi(searchUserID)
	searchName := c.DefaultQuery("name", "")

	// 查询条件
	//searchCluster := c.DefaultQuery("cluster", "")
	searchProjectId, _ := strconv.Atoi(c.DefaultQuery("projectId", ""))

	// 	数据库中拿到所有的menu列表

	var (
		objs []*models.K8sCronjob
		err  error
	)
	if searchProjectId > 0 {
		objs, err = models.GetK8sCronjobByClusterAndProjectId(searchProjectId)
		if err != nil {
			sc.Logger.Error("去数据库中拿所有的k8s计划任务配置错误",
				zap.Error(err),
			)
			common.ReqBadFailWithMessage(fmt.Sprintf("去数据库中拿所有的k8s计划任务配置错误:%v", err.Error()), c)
			return
		}

	} else {
		objs, err = models.GetK8sCronjobAll()
		if err != nil {
			sc.Logger.Error("去数据库中拿所有的k8s计划任务配置错误",
				zap.Error(err),
			)
			common.ReqBadFailWithMessage(fmt.Sprintf("去数据库中拿所有的k8s计划任务配置错误:%v", err.Error()), c)
			return
		}

	}
	// 从cache中通过 集群的id 拿到集群的clientSet
	kc := c.MustGet(common.GIN_CTX_K8s_CACHE).(*cache.K8sClusterCache)

	allIds := []int{}
	//// 遍历 role 准备menuIds 列表
	for _, obj := range objs {
		obj := obj

		// 在这里处理查询
		if searchName != "" && !strings.Contains(obj.Name, searchName) {
			continue
		}

		// 在这里处理查询
		if searchUserID != "" && int(obj.UserID) != searchUserIDInt {
			continue
		}
		allIds = append(allIds, int(obj.ID))

		//role.MenuIds = menuIds
	}

	if len(allIds) == 0 {
		common.OkWithDetailed(allIds, "ok", c)
		return
	}
	objs, err = models.GetK8sCronjobByIdsWithLimitOffset(allIds, limit, offset)
	if err != nil {
		sc.Logger.Error("limit-offset去数据库中拿所有的任务错误",
			zap.Error(err),
		)
		common.ReqBadFailWithMessage(fmt.Sprintf("limit-offset去数据库中拿所有的脚本模板错误:%v", err.Error()), c)
		return
	}
	for _, obj := range objs {
		obj := obj
		obj.FillFrontAllData()

		cjName := fmt.Sprintf("cronjob-%s-%s", obj.ProjectObj.Name, obj.Name)

		kSet := kc.GetClusterClientSetById(obj.ClusterObj.ID)
		if kSet == nil {
			msg := fmt.Sprintf("根据id找k8s集群kset缓存错误")
			sc.Logger.Error(msg, zap.Any("k8s集群配置", obj.ClusterObj.ID), zap.Error(err))
			common.FailWithMessage(err.Error(), c)
			return
		}
		ctx2, canFun2 := common.GenTimeoutContext(obj.ClusterObj.ActionTimeoutSeconds)
		defer canFun2()
		cj, err := kSet.BatchV1().CronJobs(obj.Namespace).Get(ctx2, cjName, metav1.GetOptions{})
		if err != nil {

			msg := fmt.Sprintf("根据cjName找k8s-cronjob错误:%v", cjName)
			sc.Logger.Error(msg, zap.Any("cjName", cjName), zap.Error(err))
			common.FailWithMessage(err.Error(), c)
			return
		}
		if cj.Status.LastScheduleTime == nil {
			obj.LastScheduleTime = "<unknown>"
		} else {
			obj.LastScheduleTime = translateTimestampSince(*cj.Status.LastScheduleTime)

		}

	}

	resp := &ResponseResourceCommon{
		//Total: models.GetK8sCronjobCount(), 因为是带了查询条件的 所以 count 不能是all 而是 过滤后的total

		Total: len(allIds),
		Items: objs,
	}

	common.OkWithDetailed(resp, "ok", c)
}

func createK8sCronjobOne(c *gin.Context) {
	//kset *kubernetes.Clientset, podName string, containerName string, ns string string
	sc := c.MustGet(common.GIN_CTX_CONFIG_CONFIG).(*config.ServerConfig)
	var reqObj models.K8sCronjob
	err := c.ShouldBindJSON(&reqObj)
	if err != nil {
		sc.Logger.Error("解析createK8sCronjobOne配置请求失败", zap.Any("k8s配置", reqObj), zap.Error(err))
		common.FailWithMessage(err.Error(), c)
		return
	}

	// 在这里校验字段，是否必填，范围是否正确
	err = validate.Struct(reqObj)
	if err != nil {

		// 这里为什么要判断错误是否是 ValidationErrors
		if errors1, ok := err.(validator.ValidationErrors); ok {
			common.ReqBadFailWithWithDetailed(

				gin.H{
					"翻译前": err.Error(),
					"翻译后": errors1.Translate(trans),
				},
				"请求出错",
				c,
			)
			return
		}
		common.ReqBadFailWithMessage(err.Error(), c)
		return

	}

	// TODO 下面设置人和校验权限 在noauth验证的时候会报错，因为没有过jwt模块，你自己要注释一下
	// 设置人
	userName := c.MustGet(common.GIN_CTX_JWT_USER_NAME).(string)
	dbUser, err := models.GetUserByUserName(userName)
	if err != nil {
		sc.Logger.Error("通过token解析到的userName去数据库中找User失败",
			zap.Error(err),
		)
		common.ReqBadFailWithMessage(fmt.Sprintf("通过token解析到的userName去数据库中找User失败:%v", err.Error()), c)
		return
	}

	reqObj.UserID = dbUser.ID

	reqObj.FillDefaultData()

	err = reqObj.FillFrontAllData()
	if err != nil {
		msg := fmt.Sprintf("FillFrontAllData报错:%v", err.Error())
		sc.Logger.Error(msg)
		common.ReqBadFailWithMessage(msg, c)
		return
	}

	// 在创建节点前要校验权限
	pass, _ := streeNodeOpsAdminPermissionCheck(reqObj.StreeNodeObj, c)
	if !pass {
		sc.Logger.Error("服务树节点权限校验未通过", zap.Any("reqNode", reqObj.TreeNodeId), zap.Error(err))
		common.Req403WithWithMessage("服务树节点权限校验未通过", c)
		return

	}
	//  到这里

	// 判断ns是否在这里
	// 从cache中通过 集群的id 拿到集群的clientSet
	kc := c.MustGet(common.GIN_CTX_K8s_CACHE).(*cache.K8sClusterCache)
	ok := kc.JudgeClusterNamespace(reqObj.ProjectObj.Cluster, reqObj.Namespace)
	if !ok {
		msg := fmt.Sprintf("创建k8s 计划任务失败 这个集群:%v ns%v不存在", reqObj.ProjectObj.Cluster, reqObj.Namespace)
		sc.Logger.Error(msg, zap.Any("集群", ""), zap.Error(err))
		common.FailWithMessage(err.Error(), c)
		return
	}

	// 根据服务树校验权限
	// 计划任务的集群信息来自 project的
	reqObj.Cluster = reqObj.ProjectObj.Cluster

	// 生成svc并创建
	kSet := kc.GetClusterClientSetById(reqObj.ClusterObj.ID)
	if kSet == nil {
		msg := fmt.Sprintf("根据id找k8s集群kset缓存错误")
		sc.Logger.Error(msg, zap.Any("k8s集群配置", reqObj.ClusterObj.ID), zap.Error(err))
		common.FailWithMessage(msg, c)
		return
	}

	// 先创建cronjob
	cj := reqObj.GenCronjob()

	err = applyK8sCronjobOne(c, kSet, reqObj, cj)

	if err != nil {

		msg := fmt.Sprintf("创建cj调用apply cj 创建或更新错误:%v", err.Error())
		sc.Logger.Error(msg, zap.Any("k8s集群配置", reqObj.Cluster), zap.Error(err))
		common.FailWithMessage(msg, c)
		return
	}

	// 下面级联创建
	err = reqObj.CreateOne()
	if err != nil {
		sc.Logger.Error("新增k8s-cronjob数据库失败", zap.Any("k8s集群配置", reqObj), zap.Error(err))
		common.FailWithMessage(err.Error(), c)
		return
	}

	common.OkWithData(reqObj, c)

	//common.OkWithMessage("创建成功", c)
}

// 创建或者更新cronjobment公共方法
func applyK8sCronjobOne(c *gin.Context, kSet *kubernetes.Clientset, reqObj models.K8sCronjob, cj *batchv1.CronJob) error {
	sc := c.MustGet(common.GIN_CTX_CONFIG_CONFIG).(*config.ServerConfig)

	cj.ManagedFields = nil
	tmp, _ := yaml.Marshal(cj)
	os.WriteFile(fmt.Sprintf("%v/k8s_cronb_%v.yaml", sc.LocalYamlDir, cj.Name), tmp, 0644)

	// 先去k8s 查询，有就更新，没有就创建

	ctx1, canFun1 := common.GenTimeoutContext(reqObj.ClusterObj.ActionTimeoutSeconds)
	defer canFun1()
	cjInK8s, err := kSet.BatchV1().CronJobs(cj.Namespace).Get(ctx1, cj.Name, metav1.GetOptions{})
	if err != nil {
		// 非not found的错误 -->  网络错误
		if !errors.IsNotFound(err) {
			msg := fmt.Sprintf("创建或更新cronjob的data前置获取cj对象错误:%v", err.Error())
			err = fmt.Errorf("%v %w", msg, err)
			sc.Logger.Error(msg, zap.Any("k8s集群配置", reqObj.Cluster), zap.Error(err))
			//common.FailWithMessage(msg, c)
			//c.Abort()
			return err

		}
		// 没有这个对象 ，创建即可
		ctx2, canFun2 := common.GenTimeoutContext(reqObj.ClusterObj.ActionTimeoutSeconds)
		defer canFun2()
		cj, err = kSet.BatchV1().CronJobs(cj.Namespace).Create(ctx2, cj, metav1.CreateOptions{})
		if err != nil {
			msg := fmt.Sprintf("创建cronjob错误:%v", err.Error())
			err = fmt.Errorf("%v %w", msg, err)
			sc.Logger.Error(msg, zap.Any("k8s集群配置", reqObj.Cluster), zap.Error(err))
			return err
		}
		return nil
	}

	cjInK8s.Spec = cj.Spec

	ctx3, canFun3 := common.GenTimeoutContext(reqObj.ClusterObj.ActionTimeoutSeconds)
	defer canFun3()
	cj, err = kSet.BatchV1().CronJobs(cj.Namespace).Update(ctx3, cjInK8s, metav1.UpdateOptions{})
	if err != nil {
		msg := fmt.Sprintf("更新cronjobment对象错误:%v", err.Error())
		err = fmt.Errorf("%v %w", msg, err)
		sc.Logger.Error(msg, zap.Any("k8s集群配置", reqObj.Cluster), zap.Error(err))
		return err
	}
	return nil
}

func updateK8sCronjobOne(c *gin.Context) {
	//kset *kubernetes.Clientset, podName string, containerName string, ns string string
	sc := c.MustGet(common.GIN_CTX_CONFIG_CONFIG).(*config.ServerConfig)
	var reqObj models.K8sCronjob
	err := c.ShouldBindJSON(&reqObj)
	if err != nil {
		sc.Logger.Error("解析createK8sCronjobOne配置请求失败", zap.Any("k8s配置", reqObj), zap.Error(err))
		common.FailWithMessage(err.Error(), c)
		return
	}
	// 在这里校验字段，是否必填，范围是否正确
	err = validate.Struct(reqObj)
	if err != nil {

		// 这里为什么要判断错误是否是 ValidationErrors
		if errors1, ok := err.(validator.ValidationErrors); ok {
			common.ReqBadFailWithWithDetailed(

				gin.H{
					"翻译前": err.Error(),
					"翻译后": errors1.Translate(trans),
				},
				"请求出错",
				c,
			)
			return
		}
		common.ReqBadFailWithMessage(err.Error(), c)
		return

	}

	reqObj.FillDefaultData()

	err = reqObj.FillFrontAllData()
	if err != nil {
		msg := fmt.Sprintf("FillFrontAllData报错:%v", err.Error())
		sc.Logger.Error(msg)
		common.ReqBadFailWithMessage(msg, c)
		return
	}

	// 在创建节点前要校验权限
	pass, _ := streeNodeOpsAdminPermissionCheck(reqObj.StreeNodeObj, c)
	if !pass {
		sc.Logger.Error("服务树节点权限校验未通过", zap.Any("reqNode", reqObj.TreeNodeId), zap.Error(err))
		common.Req403WithWithMessage("服务树节点权限校验未通过", c)
		return

	}
	//  到这里

	// 判断ns是否在这里
	// 从cache中通过 集群的id 拿到集群的clientSet
	kc := c.MustGet(common.GIN_CTX_K8s_CACHE).(*cache.K8sClusterCache)
	ok := kc.JudgeClusterNamespace(reqObj.ProjectObj.Cluster, reqObj.Namespace)
	if !ok {
		msg := fmt.Sprintf("创建k8s 计划任务失败 这个集群:%v ns%v不存在", reqObj.ProjectObj.Cluster, reqObj.Namespace)
		sc.Logger.Error(msg, zap.Any("集群", ""), zap.Error(err))
		common.FailWithMessage(err.Error(), c)
		return
	}

	searchCluster := reqObj.Cluster
	//searchName := reqObj.Name

	if searchCluster == "" {
		msg := "集群名称未传入"
		sc.Logger.Error(msg)
		common.ReqBadFailWithMessage(msg, c)
		return
	}

	dbObj, err := models.GetK8sClusterByName(searchCluster)
	if err != nil {
		sc.Logger.Error("根据name找k8s集群错误", zap.Any("k8s集群配置", searchCluster), zap.Error(err))
		common.FailWithMessage(err.Error(), c)
		return
	}
	// 从cache中通过 集群的id 拿到集群的clientSet
	kSet := kc.GetClusterClientSetById(dbObj.ID)
	if kSet == nil {
		msg := fmt.Sprintf("根据id找k8s集群kset缓存错误")
		sc.Logger.Error(msg, zap.Any("k8s集群配置", searchCluster), zap.Error(err))
		common.FailWithMessage(err.Error(), c)
		return
	}

	// 先创建cronjob
	cj := reqObj.GenCronjob()

	err = applyK8sCronjobOne(c, kSet, reqObj, cj)

	if err != nil {

		msg := fmt.Sprintf("创建cj调用apply cj 创建或更新错误:%v", err.Error())
		sc.Logger.Error(msg, zap.Any("k8s集群配置", reqObj.Cluster), zap.Error(err))
		common.FailWithMessage(msg, c)
		return
	}

	// 下面级联更新
	err = reqObj.UpdateOne()
	if err != nil {
		sc.Logger.Error("新增k8s-cronjob数据库失败", zap.Any("k8s集群配置", reqObj), zap.Error(err))
		common.FailWithMessage(err.Error(), c)
		return
	}

	common.OkWithData(reqObj, c)
	//common.OkWithMessage("更新成功", c)
}

func deleteK8sCronjobOne(c *gin.Context) {
	sc := c.MustGet(common.GIN_CTX_CONFIG_CONFIG).(*config.ServerConfig)
	// 校验一下 menu字段
	id := c.Param("id")

	// 先 去db中根据id找到这个对象
	intVar, _ := strconv.Atoi(id)
	dbObj, err := models.GetK8sCronjobById(intVar)
	if err != nil {
		sc.Logger.Error("根据id找k8s-计划任务配置错误", zap.Any("k8s-计划任务配置", id), zap.Error(err))
		common.FailWithMessage(err.Error(), c)
		return
	}

	dbObj.FillFrontAllData()
	//在创建节点前要校验权限
	pass, _ := streeNodeOpsAdminPermissionCheck(dbObj.StreeNodeObj, c)
	if !pass {
		sc.Logger.Error("服务树节点权限校验未通过", zap.Any("reqNode", dbObj.TreeNodeId), zap.Error(err))
		common.Req403WithWithMessage("服务树节点权限校验未通过", c)
		return
	}
	//到这里

	// 删除svc就可以了
	// 拿到k8s集群对象

	searchCluster := dbObj.ClusterObj.Name

	// 从cache中通过 集群的id 拿到集群的clientSet
	kc := c.MustGet(common.GIN_CTX_K8s_CACHE).(*cache.K8sClusterCache)
	kSet := kc.GetClusterClientSetById(dbObj.ClusterObj.ID)
	if kSet == nil {
		msg := fmt.Sprintf("根据id找k8s集群kset缓存错误")
		sc.Logger.Error(msg, zap.Any("k8s集群配置", searchCluster), zap.Error(err))
		common.FailWithMessage(err.Error(), c)
		return
	}

	ctx1, canFun1 := common.GenTimeoutContext(dbObj.ClusterObj.ActionTimeoutSeconds)
	defer canFun1()
	err = kSet.CoreV1().Services(dbObj.Namespace).Delete(ctx1, dbObj.Name, metav1.DeleteOptions{})
	if err != nil {
		msg := fmt.Sprintf("删除集群中的svc错误:%v", dbObj.Name)
		sc.Logger.Error(msg, zap.Any("k8s集群配置", searchCluster), zap.Error(err))
		common.FailWithMessage(err.Error(), c)
		return
	}

	err = dbObj.DeleteOne()
	if err != nil {
		sc.Logger.Error("根据id删除k8s-计划任务数据库错误", zap.Any("k8s-计划任务", id), zap.Error(err))
		common.FailWithMessage(err.Error(), c)
		return
	}
	common.OkWithMessage("删除成功", c)
}

func getK8sCronjobOne(c *gin.Context) {
	sc := c.MustGet(common.GIN_CTX_CONFIG_CONFIG).(*config.ServerConfig)
	// 校验一下 menu字段
	id := c.Param("id")

	// 先 去db中根据id找到这个user
	intVar, _ := strconv.Atoi(id)
	dbObj, err := models.GetK8sCronjobById(intVar)
	if err != nil {
		sc.Logger.Error("根据id找k8s计划任务错误", zap.Any("任务cronjob", id), zap.Error(err))
		common.FailWithMessage(err.Error(), c)
		return
	}
	dbObj.FillFrontAllData()

	common.OkWithData(dbObj, c)
}

type OnePodInfo struct {
	PodName string `json:"podName"`
	Ns      string `json:"ns"`
	Cluster string `json:"cluster"`
}

func getK8sCronjobLastPod(c *gin.Context) {
	sc := c.MustGet(common.GIN_CTX_CONFIG_CONFIG).(*config.ServerConfig)
	// 校验一下 menu字段
	id := c.Param("id")

	// 先 去db中根据id找到这个user
	intVar, _ := strconv.Atoi(id)
	dbObj, err := models.GetK8sCronjobById(intVar)
	if err != nil {
		sc.Logger.Error("根据id找k8s计划任务错误", zap.Any("任务cronjob", id), zap.Error(err))
		common.FailWithMessage(err.Error(), c)
		return
	}
	dbObj.FillFrontAllData()

	kc := c.MustGet(common.GIN_CTX_K8s_CACHE).(*cache.K8sClusterCache)
	kSet := kc.GetClusterClientSetById(dbObj.ClusterObj.ID)
	if kSet == nil {
		msg := fmt.Sprintf("根据id找k8s集群kset缓存错误")
		sc.Logger.Error(msg, zap.Any("k8s集群配置", dbObj.ClusterObj.ID), zap.Error(err))
		common.FailWithMessage(msg, c)
		return
	}
	// 直接拼接pod 的label selector 直接查询即可
	// cronjob-project-mock-0-001-28401201-ddfwp   0/1     Completed           0               5s
	//batch.kubernetes.io/controller-uid=d496ee7a-1723-481f-8596-78da1c213a4b,batch.kubernetes.io/job-name=cronjob-project-mock-0-001-28401201,
	//controller-uid=d496ee7a-1723-481f-8596-78da1c213a4b,
	//infra_cronjob_name=001,infra_project_name=project-mock-0,infra_stree_node=tencent.IEG.Game.CF,job-name=cronjob-project-mock-0-001-28401201

	ctx1, canFun1 := common.GenTimeoutContext(dbObj.ClusterObj.ActionTimeoutSeconds)
	defer canFun1()
	labelSelector, _ := fields.ParseSelector(fmt.Sprintf("%v=%v,%v=%v,%v=%v",
		common.K8S_APP_LABEL_STREE_NAME, dbObj.StreeNodeObj.NodePath,
		common.K8S_APP_LABEL_PROJECT_NAME, dbObj.K8sProjectName,
		common.K8S_APP_LABEL_CRONJOB_NAME, dbObj.Name,
	))
	podItems, err := kSet.CoreV1().Pods(dbObj.Namespace).List(ctx1, metav1.ListOptions{
		LabelSelector: labelSelector.String(),
	})
	if err != nil {
		msg := fmt.Sprintf("根据LabelSelector找k8s-pod错误:%v", labelSelector.String())
		sc.Logger.Error(msg, zap.Any("k8s集群配置", dbObj.Cluster), zap.Error(err))
		common.FailWithMessage(err.Error(), c)
		return
	}
	pods := podItems.Items

	sort.SliceStable(pods, func(i, j int) bool {
		return pods[i].CreationTimestamp.Unix() > pods[j].CreationTimestamp.Unix()

	})

	res := OnePodInfo{
		PodName: "",
		Ns:      dbObj.Namespace,
		Cluster: dbObj.Cluster,
	}
	if len(pods) > 0 {
		res.PodName = pods[0].Name
	}

	common.OkWithDetailed(res, "ok", c)
}

func getK8sCronjobListForSelect(c *gin.Context) {
	sc := c.MustGet(common.GIN_CTX_CONFIG_CONFIG).(*config.ServerConfig)

	objs, err := models.GetK8sCronjobAll()
	if err != nil {
		sc.Logger.Error("去数据库中拿所有的k8s项目配置错误",
			zap.Error(err),
		)
		common.ReqBadFailWithMessage(fmt.Sprintf("去数据库中拿所有的k8s项目配置错误:%v", err.Error()), c)
		return
	}
	res := []common.CommonSelectOneItemValueInt{}
	for _, obj := range objs {
		obj := obj
		res = append(res, common.CommonSelectOneItemValueInt{
			Label: fmt.Sprintf("集群:%v 计划任务:%v", obj.Cluster, obj.Name),
			Value: int(obj.ID),
		})
	}

	common.OkWithDetailed(res, "ok", c)

}

func batchDeleteK8sCronjob(c *gin.Context) {
	//kset *kubernetes.Clientset, podName string, containerName string, ns string string
	sc := c.MustGet(common.GIN_CTX_CONFIG_CONFIG).(*config.ServerConfig)
	var reqObj K8sBatchDeleteInstance
	err := c.ShouldBindJSON(&reqObj)
	if err != nil {
		sc.Logger.Error("解析批量删除K8sCronjob请求失败", zap.Any("k8s配置", reqObj), zap.Error(err))
		common.FailWithMessage(err.Error(), c)
		return
	}

	// 在这里校验字段，是否必填，范围是否正确
	err = validate.Struct(reqObj)
	if err != nil {

		// 这里为什么要判断错误是否是 ValidationErrors
		if errors, ok := err.(validator.ValidationErrors); ok {
			common.ReqBadFailWithWithDetailed(

				gin.H{
					"翻译前": err.Error(),
					"翻译后": errors.Translate(trans),
				},
				"请求出错",
				c,
			)
			return
		}
		common.ReqBadFailWithMessage(err.Error(), c)
		return

	}

	for _, id := range reqObj.Ids {

		dbK8sCronjob, err := models.GetK8sCronjobById(id)
		if err != nil {
			msg := fmt.Sprintf("根据id找K8sCronjob配置错误")
			sc.Logger.Error(msg, zap.Any("k8s集群配置", id), zap.Error(err))
			common.FailWithMessage(msg, c)
			return
		}
		err = dbK8sCronjob.FillFrontAllData()
		if err != nil {
			msg := fmt.Sprintf("dbK8sCronjob.FillFrontAllData报错:%v", err.Error())
			sc.Logger.Error(msg)
			common.ReqBadFailWithMessage(msg, c)
			return
		}

		// 根据服务树校验权限
		/*权限校验开始*/

		//
		// 在创建节点前要校验权限
		pass, _ := streeNodeOpsAdminPermissionCheck(dbK8sCronjob.StreeNodeObj, c)
		if !pass {
			msg := fmt.Sprintf("服务树节点权限校验未通过:%v", dbK8sCronjob.StreeNodeObj.NodePath)
			sc.Logger.Error(msg, zap.Any("reqNode", dbK8sCronjob.TreeNodeId), zap.Error(err))
			common.Req403WithWithMessage(msg, c)
			return

		}
		/*权限校验结束*/

		searchCluster := dbK8sCronjob.Cluster

		if searchCluster == "" {
			msg := "集群名称未传入"
			sc.Logger.Error(msg)
			common.ReqBadFailWithMessage(msg, c)
			return
		}

		// 从cache中通过 集群的id 拿到集群的clientSet
		kc := c.MustGet(common.GIN_CTX_K8s_CACHE).(*cache.K8sClusterCache)
		kSet := kc.GetClusterClientSetById(dbK8sCronjob.ClusterObj.ID)
		if kSet == nil {
			msg := fmt.Sprintf("根据id找k8s集群kset缓存错误")
			sc.Logger.Error(msg, zap.Any("k8s集群配置", searchCluster), zap.Error(err))
			common.FailWithMessage(msg, c)
			return
		}

		cjName := fmt.Sprintf("cronjob-%s-%s", dbK8sCronjob.K8sProjectName, dbK8sCronjob.Name)

		err = dbK8sCronjob.DeleteOne()
		if err != nil {
			msg := fmt.Sprintf("删除k8s-K8sCronjob数据库错误 :%v:%v", cjName, err.Error())
			sc.Logger.Error(msg)
			common.ReqBadFailWithMessage(msg, c)
			return
		}

		// 先删除K8sCronjob 再删除数据库
		ctx1, canFun1 := common.GenTimeoutContext(dbK8sCronjob.ClusterObj.ActionTimeoutSeconds)
		defer canFun1()

		err = kSet.BatchV1().CronJobs(dbK8sCronjob.Namespace).Delete(ctx1, cjName, metav1.DeleteOptions{})
		if err != nil {
			msg := fmt.Sprintf("删除K8sCronjob错误 :%v:%v", cjName, err.Error())
			sc.Logger.Error(msg)
			common.ReqBadFailWithMessage(msg, c)
			return
		}

	}

	common.OkWithMessage("删除成功", c)

}
